#pragma once
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include "risk.h"
#include "strategy.h"
#include <chrono>
#include <functional>

namespace hft {

/**
 * @brief 监控指标接口类
 * 
 * 所有监控指标都需要继承此基类并实现相应接口
 */
class MonitorMetric {
public:
    MonitorMetric() = default;
    virtual ~MonitorMetric() = default;

    /**
     * @brief 初始化监控指标
     * @param config 配置参数
     * @return 是否初始化成功
     */
    virtual bool init(const std::string& config) = 0;

    /**
     * @brief 更新指标值
     * @param value 指标值
     */
    virtual void update(double value) = 0;

    /**
     * @brief 获取指标名称
     * @return 指标名称
     */
    virtual std::string getName() const = 0;

    /**
     * @brief 获取指标值
     * @return 指标值
     */
    virtual double getValue() const = 0;

    /**
     * @brief 获取指标更新时间
     * @return 更新时间
     */
    virtual std::chrono::system_clock::time_point getUpdateTime() const = 0;
};

/**
 * @brief 监控管理器类
 * 
 * 负责管理和收集所有监控指标
 */
class MonitorManager {
public:
    MonitorManager() = default;
    ~MonitorManager() = default;

    /**
     * @brief 初始化监控管理器
     * @param config 配置参数
     * @return 是否初始化成功
     */
    bool init(const std::string& config);

    /**
     * @brief 添加监控指标
     * @param metric 监控指标
     */
    void addMetric(std::shared_ptr<MonitorMetric> metric);

    /**
     * @brief 更新监控指标
     * @param name 指标名称
     * @param value 指标值
     */
    void updateMetric(const std::string& name, double value);

    /**
     * @brief 获取监控指标
     * @param name 指标名称
     * @return 监控指标
     */
    std::shared_ptr<MonitorMetric> getMetric(const std::string& name);

    /**
     * @brief 获取所有监控指标
     * @return 监控指标列表
     */
    std::vector<std::shared_ptr<MonitorMetric>> getAllMetrics();

private:
    std::unordered_map<std::string, std::shared_ptr<MonitorMetric>> metrics_;
};

// 监控指标
struct MonitorMetrics {
    // 延迟指标
    struct LatencyMetrics {
        double avg_latency;        // 平均延迟
        double p95_latency;        // 95%延迟
        double p99_latency;        // 99%延迟
        double max_latency;        // 最大延迟
        std::vector<double> latencies; // 延迟序列
    };

    // 订单指标
    struct OrderMetrics {
        int64_t total_orders;      // 总订单数
        int64_t active_orders;     // 活动订单数
        int64_t filled_orders;     // 已成交订单数
        int64_t cancelled_orders;  // 已撤销订单数
        int64_t rejected_orders;   // 已拒绝订单数
        double avg_order_size;     // 平均订单大小
        double avg_order_value;    // 平均订单价值
    };

    // 成交指标
    struct TradeMetrics {
        int64_t total_trades;      // 总成交数
        double total_volume;       // 总成交量
        double total_value;        // 总成交额
        double avg_trade_size;     // 平均成交大小
        double avg_trade_value;    // 平均成交价值
        double avg_slippage;       // 平均滑点
    };

    // 持仓指标
    struct PositionMetrics {
        int64_t total_positions;   // 总持仓数
        double total_position_value; // 总持仓价值
        double avg_position_size;  // 平均持仓大小
        double avg_position_value; // 平均持仓价值
        double max_position_value; // 最大持仓价值
        double min_position_value; // 最小持仓价值
    };

    // 账户指标
    struct AccountMetrics {
        double balance;            // 账户余额
        double available;          // 可用资金
        double margin;             // 保证金
        double commission;         // 手续费
        double frozen_margin;      // 冻结保证金
        double frozen_commission;  // 冻结手续费
    };

    // 风控指标
    struct RiskMetrics {
        double max_drawdown;       // 最大回撤
        double current_drawdown;   // 当前回撤
        double daily_pnl;          // 当日盈亏
        double total_pnl;          // 总盈亏
        double win_rate;           // 胜率
        double profit_factor;      // 盈亏比
        double sharpe_ratio;       // 夏普比率
    };

    // 系统指标
    struct SystemMetrics {
        double cpu_usage;          // CPU使用率
        double memory_usage;       // 内存使用率
        double network_usage;      // 网络使用率
        int64_t message_count;     // 消息数量
        double message_rate;       // 消息速率
        int64_t error_count;       // 错误数量
        double error_rate;         // 错误率
    };

    LatencyMetrics latency;
    OrderMetrics order;
    TradeMetrics trade;
    PositionMetrics position;
    AccountMetrics account;
    RiskMetrics risk;
    SystemMetrics system;
};

// 监控接口
class Monitor {
public:
    virtual ~Monitor() = default;

    // 初始化监控
    virtual bool init(const YAML::Node& config) = 0;

    // 启动监控
    virtual void start() = 0;

    // 停止监控
    virtual void stop() = 0;

    // 更新指标
    virtual void updateMetrics(const MonitorMetrics& metrics) = 0;

    // 获取指标
    virtual const MonitorMetrics& getMetrics() const = 0;

    // 导出指标
    virtual bool exportMetrics(const std::string& format) = 0;
};

// Prometheus监控
class PrometheusMonitor : public Monitor {
public:
    bool init(const YAML::Node& config) override;
    void start() override;
    void stop() override;
    void updateMetrics(const MonitorMetrics& metrics) override;
    const MonitorMetrics& getMetrics() const override { return metrics_; }
    bool exportMetrics(const std::string& format) override;

private:
    void registerMetrics();
    void updateLatencyMetrics();
    void updateOrderMetrics();
    void updateTradeMetrics();
    void updatePositionMetrics();
    void updateAccountMetrics();
    void updateRiskMetrics();
    void updateSystemMetrics();

    YAML::Node config_;
    MonitorMetrics metrics_;
    bool running_;
};

// 控制台监控
class ConsoleMonitor : public Monitor {
public:
    bool init(const YAML::Node& config) override;
    void start() override;
    void stop() override;
    void updateMetrics(const MonitorMetrics& metrics) override;
    const MonitorMetrics& getMetrics() const override { return metrics_; }
    bool exportMetrics(const std::string& format) override;

private:
    void printMetrics();
    void printLatencyMetrics();
    void printOrderMetrics();
    void printTradeMetrics();
    void printPositionMetrics();
    void printAccountMetrics();
    void printRiskMetrics();
    void printSystemMetrics();

    YAML::Node config_;
    MonitorMetrics metrics_;
    bool running_;
};

// 文件监控
class FileMonitor : public Monitor {
public:
    bool init(const YAML::Node& config) override;
    void start() override;
    void stop() override;
    void updateMetrics(const MonitorMetrics& metrics) override;
    const MonitorMetrics& getMetrics() const override { return metrics_; }
    bool exportMetrics(const std::string& format) override;

private:
    void writeMetrics();
    void writeLatencyMetrics();
    void writeOrderMetrics();
    void writeTradeMetrics();
    void writePositionMetrics();
    void writeAccountMetrics();
    void writeRiskMetrics();
    void writeSystemMetrics();

    YAML::Node config_;
    MonitorMetrics metrics_;
    bool running_;
    std::string file_path_;
};

// 监控工厂
class MonitorFactory {
public:
    static std::shared_ptr<Monitor> createMonitor(const std::string& type) {
        if (type == "prometheus") {
            return std::make_shared<PrometheusMonitor>();
        } else if (type == "console") {
            return std::make_shared<ConsoleMonitor>();
        } else if (type == "file") {
            return std::make_shared<FileMonitor>();
        }
        return nullptr;
    }
};

} // namespace hft 
